package com.wisdom.smartbook.utils;

import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Environment;
import android.os.FileUtils;
import android.os.StatFs;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.widget.Toast;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;

/**
 * 文件管理类
 */
public final class FileManager {

    public static final String CACHE_ROOT_DIRECTORY = "smartbookCache"; // 缓存根目录
    public static final String CACHE_IMAGE_DIRECTORY = "imageCache"; // 缓存图片目录
    public static final String CACHE_AUDIO_DIRECTORY = "audioCache"; // 缓存语音目录
    public static final String CACHE_FILE_DIRECTORY = "fileCache"; // 缓存其他文件目录
    public static final String CACHE_CRASH_DIRECTORY = "crash"; // 错误日志目录
    public static final String CACHE_VIDEO_DIRECTORY = "videoCache"; // 缓存视频目录

    public static final String CACHE_TEMP_DIRECTORY = "temp"; // 临时缓存目录，需要及时清掉
    public static final String CACHE_IMAGE_LOADER_DIRECTORY = "imageLoader";//ImageLoader缓存目录

    /**
     * 判断是否存在SD卡
     *
     * @return
     */
    public static final boolean hasSDCard() {

        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

    public static final String getCachePath(Context context) {
        if (hasSDCard()) {
            return Environment.getExternalStorageDirectory().toString() + File.separator + CACHE_ROOT_DIRECTORY;
        } else {
            // return context.getFilesDir()+File.separator+CACHE_ROOT_DIRECTORY;
            return context.getCacheDir() + File.separator + CACHE_ROOT_DIRECTORY;
        }

    }

    public static final File creatFile(Context context, String fileName) {
        String filePath = getFileCachePath(context) + File.separator + fileName;
        File file = new File(filePath);
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
        }
        return file;
    }

    public static final String checkFileExist(Context context, String fileName) {
        String filePath = getFileCachePath(context) + File.separator + fileName;
        File file = new File(filePath);
        if (file.exists()) {
            return filePath;
        }
        return "";
    }

    /**
     * 获取图片缓存路径
     *
     * @param context
     * @return
     */
    public static final String getImageCachePath(Context context) {

        String path = getCachePath(context) + File.separator + CACHE_IMAGE_DIRECTORY;

        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 获取  图片缓存路径
     *
     * @param context
     * @return
     */
    public static final String getClassCachePath(Context context, String dirName) {
        String path = getCachePath(context) + File.separator + dirName;
        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 获取  图片缓存路径
     *
     * @param context
     * @return
     */
    public static final String getClassCachePath(Context context, String dirName, String dirName2) {
        String path = getCachePath(context) + File.separator + dirName + File.separator + dirName2;
        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 获取语音缓存路径（网络下载的语音）
     *
     * @param context
     * @return
     */
    public static final String getAudioCachePath(Context context) {
        String path = getCachePath(context) + File.separator + CACHE_AUDIO_DIRECTORY;
        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 获取缓存文件路径
     *
     * @param context
     * @return
     */
    public static final String getFileCachePath(Context context) {
        String path = getCachePath(context) + File.separator + CACHE_FILE_DIRECTORY;

        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    public static final String getFileCrashPath(Context context) {
        String path = getCachePath(context) + File.separator + CACHE_CRASH_DIRECTORY;

        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 获取视频缓存路径
     *
     * @param context
     * @return
     */
    public static final String getVideoCachePath(Context context) {
        String path = getCachePath(context) + File.separator + CACHE_VIDEO_DIRECTORY;
        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 获取临时缓存文件，由于存放录制的语音，临时图片，文件等
     *
     * @param context
     * @return
     */
    public static final String getTempPath(Context context) {

        String path = getCachePath(context) + File.separator + CACHE_TEMP_DIRECTORY;

        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }

    /**
     * 清除临时图片缓存
     *
     * @param context
     */
    public static final boolean clearTempCache(Context context) {

        try {
            return clearDir(getTempPath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public static final boolean clearImageCache(Context context) {

        try {
            return clearDir(getImageCachePath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 清除语音缓存
     *
     * @param context
     */
    public static final boolean clearAudioCache(Context context) {

        try {
            return clearDir(getAudioCachePath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 清除语音缓存
     *
     * @param context
     */
    public static final boolean clearVideoCache(Context context) {

        try {
            return clearDir(getVideoCachePath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 清除文件缓存
     *
     * @param context
     */
    public static final boolean clearFileCache(Context context) {

        try {
            return clearDir(getFileCachePath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 清除所有缓存
     *
     * @param context
     */
    public static final boolean clearAllCache(Context context) {

        try {
            return clearDir(getCachePath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 计算SD卡的剩余空间
     *
     * @return 返回-1，说明没有安装sd卡
     */
    public static long getFreeDiskSpace() {
        String status = Environment.getExternalStorageState();
        long freeSpace = 0;
        if (status.equals(Environment.MEDIA_MOUNTED)) {
            try {
                File path = Environment.getExternalStorageDirectory();
                StatFs stat = new StatFs(path.getPath());
                long blockSize = stat.getBlockSize();
                long availableBlocks = stat.getAvailableBlocks();
                freeSpace = availableBlocks * blockSize / 1024;
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            return -1;
        }
        return (freeSpace);
    }

    /**
     * 获取ImageLoader缓存路径
     *
     * @param context
     * @return
     */
    public static final String getImageLoaderCachePath(Context context) {

        String path = getCachePath(context) + File.separator + CACHE_IMAGE_LOADER_DIRECTORY;

        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        return path;
    }


    /**
     * 清除ImageLoader缓存路径
     *
     * @param context
     */
    public static final boolean clearImageLoaderCache(Context context) {

        try {
            return clearDir(getImageLoaderCachePath(context));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 清空文件夹，但不删除该文件夹
     *
     * @param dirPath
     */
    public static boolean clearDir(String dirPath) {

        if (dirPath == null) {
            return false;
        }

        File f = new File(dirPath);// 定义文件路径

        File delFile[] = f.listFiles();

        final int i = f.listFiles().length;

        for (int j = 0; j < i; j++) {

            if (delFile[j].isDirectory()) {
                try {
                    deleteDir(delFile[j].getAbsolutePath());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            delFile[j].delete();
        }
        return true;
    }

    /**
     * 删除指定的文件夹
     *
     * @param filepath
     * @throws IOException
     */
    public static boolean deleteDir(String filepath) throws IOException {

        File f = new File(filepath);// 定义文件路径

        if (f.exists() && f.isDirectory()) {// 判断是文件还是目录

            if (f.listFiles().length == 0) {// 若目录下没有文件则直接删除

                f.delete();

            } else { // 若有则把文件放进数组，并判断是否有下级目录

                File delFile[] = f.listFiles();

                final int i = f.listFiles().length;

                for (int j = 0; j < i; j++) {

                    if (delFile[j].isDirectory()) {
                        deleteDir(delFile[j].getAbsolutePath());// 递归调用del方法并取得子目录路径
                    }
                    delFile[j].delete();
                }

                f.delete();
            }
        }
        return true;
    }/**
     * 删除指定的文件夹
     *
     * @param filepath
     * @throws IOException
     */
    public static void deleteFile(String filepath) {
        File f = new File(filepath);// 定义文件路径
        if (f.exists() ) {// 判断是文件还是目录
            f.delete();
            KLog.d("文件删除成功");
        }else {
            KLog.d("文件不存在");
        }
    }


    public static void saveBitmap(Context activity, String filePath) {
        Bitmap bitmap = BitmapFactory.decodeFile(filePath);
        //这个file要是真实路径创建的file
        try {
            //获取要保存的图片的位图
            //创建一个保存的Uri
            ContentValues values = new ContentValues();
            //设置图片名称
            values.put(MediaStore.Images.Media.DISPLAY_NAME, System.currentTimeMillis() + "code.png");
            //设置图片格式
            values.put(MediaStore.Images.Media.MIME_TYPE, "image/png");
            //设置图片路径
            values.put(MediaStore.Images.Media.RELATIVE_PATH, Environment.DIRECTORY_PICTURES);
            Uri saveUri = activity.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
            if (TextUtils.isEmpty(saveUri.toString())) {
              KLog.d("保存失败！文件路径为空");
                return;
            }
            OutputStream outputStream = activity.getContentResolver().openOutputStream(saveUri);
            //将位图写出到指定的位置
            //第一个参数：格式JPEG 是可以压缩的一个格式 PNG 是一个无损的格式
            //第二个参数：保留原图像90%的品质，压缩10% 这里压缩的是存储大小
            //第三个参数：具体的输出流
            if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)) {
                KLog.d("保存成功");
            } else {
                KLog.d("保存失败！文件路径为空");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 最后通知图库更新
        activity.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,
                Uri.fromFile(new File(filePath))));
    }

}
